/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package com.market.datos;

import java.util.*; 
import java.sql.*; 

/**
 *
 * @author Bambino
 */
public class cDatos {
   
    // Conexion con Mysql 
    private final String driver = "com.mysql.jdbc.Driver";
    private final String url = "jdbc:mysql://localhost:3306/bd_marketfarm";
    private final String user = "root";
    private final String pasw = "root";
        
    private Connection conexion;  
    
    /**
     * Crea una nueva instancia de la clase cDatos
     */
    public cDatos() {
    }
    
    public void openConnection() { 
      try{ 
         Class.forName(driver);
	 this.conexion = DriverManager.getConnection( url, user, pasw );
      }catch(Exception e){ 
         e.printStackTrace(); 
      } 
    }
	   
    // cierra la conexion a la BD 
    public void closeConnection() { 
      try{ 
         // cierra la conexion 
         this.conexion.close(); 
      }catch(SQLException e){ 
         e.printStackTrace(); 
      } 
    } 
	   
    /** Inicia una transacción. */
    public void IniciarTransaccion() throws SQLException {
        this.conexion.setAutoCommit(false);
    }
    
    /** Finaliza una transacción y graba los cambios. */
    public void FinalizarTransaccion() throws SQLException {
        this.conexion.commit();
        this.conexion.setAutoCommit(true);
    }
    
    /** Deshace los cambios de una transacción.  */
    public void DeshacerTransaccion() throws SQLException {
        this.conexion.rollback();
    }
    
    /** Establece AutoCommit. */
    public void EstablecerAutoCommit(boolean estado) throws SQLException {
        this.conexion.setAutoCommit(estado);
    }
    
    
    /** Devuelve el valor actual de la propiedad 'conexion' */
    public Connection getConnection() {
        return conexion;
    }
    
    /** Establece externamente el valor de la propiedad 'conexion'.  */
    public void setConnection(Connection conexion) {
        this.conexion = conexion;
    }

   // convierte un ResultSet a un Vector 
   private Vector ResultSetToVector(ResultSet rs) throws SQLException { 
      Vector vRows = new Vector(); 
      // lee registro por registro 
      while(rs.next()){ 
         Vector vCol = new Vector(); 
         // lee cada campo del query 
         int nroFields =rs.getMetaData().getColumnCount(); 
         for(int i = 1 ; i<=nroFields ; i++){ 
            String strTmp = rs.getString(i); 
            vCol.add(strTmp); 
         } 
         vRows.add(vCol); 
      } 
      return vRows; 
    } 
	   
   // ejecuta delete,insert ó update 
   private void performance(String str){ 
      try{ 
         // crea el statement 
         Statement stmt = this.conexion.createStatement(); 
         // ejecuta el update 
         stmt.executeUpdate(str); 
         //cierra statement 
         stmt.close(); 
      } catch(SQLException e){ 
         e.printStackTrace(); 
      } 
   } 

   // ejecuta solo los query 
   public Vector query(String strQuery){ 
      Vector vRet = null; 
      try{ 
         // crea el statement 
         Statement stmt = this.conexion.createStatement();
         // ejecuta el query 
         ResultSet rs = stmt.executeQuery(strQuery); 
         // convierte el ResultSet to Vector 
         vRet = ResultSetToVector(rs); 
         // cierra el ResultSet 
         rs.close(); 
         // cierra el statement 
         stmt.close(); 
      }catch(SQLException e){ 
          e.printStackTrace(); 
      } 
      return vRet; 
    } 

    // ejecuta un delete 
    public void delete(String strDelete){ 
      performance(strDelete); 
    } 
	   
    // ejecuta un update 
    public void update(String strUpdate){ 
       performance(strUpdate); 
    } 
	   
    // ejecuta un insert 
    public void insert(String strInsert){ 
       performance(strInsert); 
    } 
    
    // SQL con parametros
    public void performance(String str, String aParam[] ){
      PreparedStatement pstm;
      try{ 
         // crea el statement 
         pstm = this.conexion.prepareStatement( str );
         // ejecuta el update
         for ( int xc=0 ; xc < aParam.length ; xc ++ ) 
            pstm.setString( xc+1, aParam[xc] );
         pstm.executeUpdate(); 
         //cierra statement 
         pstm.close();
      } catch(SQLException e){ 
         e.printStackTrace(); 
      } 
   } 
    
   public Vector query(String strQuery, String xcod ){ 
      Vector vRet = null; 
      try{ 
         // crea el statement 
         PreparedStatement pstm = this.conexion.prepareStatement( strQuery );
         // Inicializa parametros
         pstm.setString( 1, xcod );
         // ejecuta el query 
         ResultSet rs = pstm.executeQuery(); 
         // convierte el ResultSet to Vector 
         vRet = ResultSetToVector(rs); 
         // cierra el ResultSet 
         rs.close(); 
         // cierra el statement 
         pstm.close(); 
      } catch(SQLException e){ 
	e.printStackTrace(); 
      } 
      return vRet; 
    }
	   
    public void delete(String strDelete, String aParam[] ){ 
        performance(strDelete, aParam); 
    } 

    public void update(String strUpdate, String aParam[] ){ 
        performance(strUpdate, aParam); 
    } 

    public void insert(String strInsert, String aParam[] ){ 
        performance(strInsert, aParam); 
    } 
    
    // Ejecutar procedimientos almacenados
    public void sp_proc( String sp_name, String aParam[] ) {
       try {
          CallableStatement cs = this.conexion.prepareCall( sp_name );
          for( int xc=0 ; xc < aParam.length ; xc++)
	     cs.setString( xc+1, aParam[xc]);
	  cs.execute();
	} catch( Exception e ){ 
	    e.printStackTrace(); 
	}
    }

    public void sp_proc( String sp_name, String aParam ) {
       try {
	   CallableStatement cs = this.conexion.prepareCall( sp_name );
	   cs.setString( 1, aParam );
           cs.execute();
       } catch( Exception e ){ 
	   e.printStackTrace(); 
       }
    }

}
